Neki rezultati u vizualizaciji kitty mreže su mi, well, bili čudni, odnosno činilo se da neuroni pokazuju više-nego-što-bih-očekivao pravilnosti u checkpointu prije ikakvog treniranja. Zato ovdje ide svježe-učitana mreža pod skalpel, s težinama određenima s tim koja je je već defaultna PyTorch metoda inicijalizacije.
Sav kod i metode su samo copy-paste iz kitty vizualizacija bilježnice, a čak je i mreža copy-pasteana, samo ovdje nisam ovdje učitavao nikakve checkpointe.
pip install torch-lucent
from lucent.optvis.transform import pad, jitter, random_rotate, random_scale
from lucent.optvis import render, param, transform, objectives
from tqdm import tqdm
import numpy as np
import torch
from lucent.optvis import render, param, transform, objectives
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# da bilježnice budu manje:
%config InlineBackend.figure_format = 'jpg'
import warnings
warnings.filterwarnings('ignore')
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super().__init__()
self.bn0 = nn.BatchNorm2d(3)
self.conv1 = nn.Conv2d(3, 9, 3)
self.pool1 = nn.AvgPool2d(4, 4)
self.conv1_bn = nn.BatchNorm2d(9)
self.conv2 = nn.Conv2d(9, 16, 3)
self.pool2 = nn.AvgPool2d(4, 4)
self.conv2_bn = nn.BatchNorm2d(16)
self.conv3 = nn.Conv2d(16, 25, 3)
self.pool3 = nn.AvgPool2d(4, 4)
self.conv3_bn = nn.BatchNorm2d(25)
self.conv4 = nn.Conv2d(25, 36, 3)
self.pool4 = nn.AvgPool2d(2 , 2)
self.fc = nn.Linear(324, 4)
def forward(self, x):
x = self.bn0(x)
x = self.conv1_bn(self.pool1(F.relu(self.conv1(x))))
x = self.conv2_bn(self.pool2(F.relu(self.conv2(x))))
x = self.conv3_bn(self.pool3(F.relu(self.conv3(x))))
x = self.pool4(F.relu(self.conv4(x)))
x = torch.flatten(x, 1) # flatten all dimensions except batch
x = self.fc(x)
return x
model = Net()
model = model.to(device)
model.eval()
Net( (bn0): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (conv1): Conv2d(3, 9, kernel_size=(3, 3), stride=(1, 1)) (pool1): AvgPool2d(kernel_size=4, stride=4, padding=0) (conv1_bn): BatchNorm2d(9, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (conv2): Conv2d(9, 16, kernel_size=(3, 3), stride=(1, 1)) (pool2): AvgPool2d(kernel_size=4, stride=4, padding=0) (conv2_bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (conv3): Conv2d(16, 25, kernel_size=(3, 3), stride=(1, 1)) (pool3): AvgPool2d(kernel_size=4, stride=4, padding=0) (conv3_bn): BatchNorm2d(25, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (conv4): Conv2d(25, 36, kernel_size=(3, 3), stride=(1, 1)) (pool4): AvgPool2d(kernel_size=2, stride=2, padding=0) (fc): Linear(in_features=324, out_features=4, bias=True) )
def lucent_show_layer(layer, n_channels,
param_f=None, transforms=None,
optimizer=None, preprocess=True, image_size=128):
n_row = floor( sqrt( n_channels ) )
n_col = floor( sqrt( n_channels ) )
_, axs = plt.subplots(n_row, n_col, figsize=(17.55, 18))
axs = axs.flatten()
for ix, ax in zip(range(n_row*n_col), axs):
img = render.render_vis(model, f"{layer}:{ix}", param_f=param_f,
transforms=transforms, preprocess=preprocess, progress=False, show_image=False)[0]
img = np.reshape(img, (image_size, image_size, 3))
ax.imshow(img)
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xticks([])
ax.set_yticks([])
ax.margins(x=0, y=0, tight=True)
plt.subplots_adjust(wspace=0, hspace=0)
plt.show()
lucent_show_layer('conv1', 9)
9it [02:24, 16.07s/it]
lucent_show_layer('conv2', 16)
lucent_show_layer('conv3', 25)
25it [04:11, 10.08s/it]
!git clone https://github.com/pytorch/captum
%cd captum
!git checkout "optim-wip"
!pip3 --quiet install -e .
import sys
sys.path.append('/content/captum')
%cd ..
import captum.optim as optimviz
import torchvision
from typing import Callable, Iterable, Optional
def vis_neuron_large(
# funkcija adaptirana iz:
# https://colab.research.google.com/drive/1Zv7w03hOHfBWaEDMpSR1MA4D6IpAwZln
model: torch.nn.Module, target: torch.nn.Module, channel: int
) -> None:
image = optimviz.images.NaturalImage((640, 640)).to(device)
transforms = torch.nn.Sequential(
torch.nn.ReflectionPad2d(2),
optimviz.transforms.RandomSpatialJitter(8),
optimviz.transforms.RandomScale(scale=(2.15, 1.85, 2, 1.95, 2.05)),
torchvision.transforms.RandomRotation(degrees=(-15, 15)),
optimviz.transforms.RandomSpatialJitter(64),
optimviz.transforms.CenterCrop((640, 640)),
)
loss_fn = optimviz.loss.NeuronActivation(target, channel)
obj = optimviz.InputOptimization(model, loss_fn, image, transforms)
history = obj.optimize(optimviz.optimization.n_steps(512, False))
return image()
def visualize_layer_captum(layer, grid_dim):
n_row = grid_dim
n_col = grid_dim
_, axs = plt.subplots(n_row, n_col, figsize=(19.55, 20))
axs = axs.flatten()
for ix, ax in zip(range(n_row*n_col), axs):
img = vis_neuron_large(model, layer, ix)
img = img.permute(0, 2, 3, 1)
with torch.no_grad():
img = img.cpu().numpy()
img = img.reshape((640,640,3))
ax.imshow(img)
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xticks([])
ax.set_yticks([])
ax.margins(x=0, y=0, tight=True)
plt.subplots_adjust(wspace=0, hspace=0)
plt.show()
visualize_layer_captum(model.conv1, 3)
visualize_layer_captum(model.conv2, 4)
visualize_layer_captum(model.conv3, 5)
visualize_layer_captum(model.conv4, 6)